package com.example.questionnaire.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.common.utils.PageUtils;
import com.example.common.utils.Query;
import com.example.questionnaire.constant.ExpenseConstants;
import com.example.questionnaire.constant.QuestionnaireConstant;
import com.example.questionnaire.dao.AnswererTeamDao;
import com.example.questionnaire.dao.QuestionnaireDao;
import com.example.questionnaire.entity.QuestionnaireEntity;
import com.example.questionnaire.entity.ResultEntity;
import com.example.questionnaire.entity.UserEntity;
import com.example.questionnaire.service.QuestionnaireService;
import com.example.questionnaire.service.ResultService;
import com.example.questionnaire.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;


@Service("questionnaireService")
public class QuestionnaireServiceImpl extends ServiceImpl<QuestionnaireDao, QuestionnaireEntity> implements QuestionnaireService {

    @Autowired
    ResultService resultService;

    @Autowired
    QuestionnaireDao questionnaireDao;

    @Override
    public PageUtils queryPage(Map<String, Object> params) {
        QueryWrapper<QuestionnaireEntity> wrapper =
                new QueryWrapper<QuestionnaireEntity>();
        wrapper.eq("is_deleted", 0);

        if (params.get("questionnaireName") != null) {
            wrapper.like("questionnaire_name", params.get("questionnaireName"));
        }

        if (params.get("userId") != null) {
            if(!params.get("userId").toString().equals("1")) {
                wrapper.eq("user_id", params.get("userId"));
            }
        }

        IPage<QuestionnaireEntity> page = this.page(
                new Query<QuestionnaireEntity>().getPage(params),
                wrapper);

        return new PageUtils(page);
    }

    //    伪删除
    @Override
    public boolean removeTemporary(List<Integer> asList) {
        boolean flag = true;
        for (Integer integer : asList) {
            UpdateWrapper<QuestionnaireEntity> updateWrapper = new UpdateWrapper<QuestionnaireEntity>();
            updateWrapper.set("is_deleted", 1);
            updateWrapper.eq("id", integer);
            updateWrapper.ne("status", QuestionnaireConstant.release.getStatus());
            boolean update = this.update(updateWrapper);
            if (!update) {
                flag = update;
            }
        }
        return flag;
    }

    @Override
    public PageUtils getDeletedList(Map<String, Object> params) {
        QueryWrapper<QuestionnaireEntity> wrapper = new QueryWrapper<QuestionnaireEntity>();
        wrapper.eq("is_deleted", 1);

        if (params.get("userId") != null) {
            wrapper.eq("user_id", params.get("userId"));
        }

        IPage<QuestionnaireEntity> page = this.page(new Query<QuestionnaireEntity>().getPage(params), wrapper);
        return new PageUtils(page);
    }

    @Autowired
    UserService userService;

    @Transactional
    @Override
    public void release(Integer id, Integer[] answererIds) {
//发送的个数
        QuestionnaireEntity entity = this.getById(id);
        entity.setReleaseTime(new Date());
        entity.setStatus(QuestionnaireConstant.release.getStatus());
        this.updateById(entity);

//        创建答卷数量
        List<ResultEntity> collect = Arrays.stream(answererIds).map(item -> {
                    ResultEntity resultEntity = new ResultEntity();
                    resultEntity.setAnswererId(item);
                    resultEntity.setAnswerList(entity.getProblemList());
                    resultEntity.setIsFinish(0);
                    resultEntity.setQuestionnaireName(entity.getQuestionnaireName());
                    resultEntity.setQuestionnaireId(id);
                    resultEntity.setLimitTime(entity.getLimitTime());
                    return resultEntity;
                }
        ).collect(Collectors.toList());
        resultService.saveBatch(collect);
    }

    //导入优质问卷
    @Override
    public void importQuestionnaire(Integer id) {
        QuestionnaireEntity entity = this.getById(id);

        entity.setId(null);
        entity.setIsExcellent(0);
        entity.setStatus(QuestionnaireConstant.newOne.getStatus());
        entity.setEndTime(null);
        entity.setCreationDate(new Date());
        entity.setReleaseTime(null);

        this.save(entity);
    }


    @Override
    public void recover(Integer id) {
        QuestionnaireEntity entity = this.getById(id);
        entity.setIsDeleted(0);
        this.updateById(entity);
    }

    @Override
    public boolean updateByIdIsRelased(QuestionnaireEntity questionnaire) {
        Integer id = questionnaire.getId();
        QuestionnaireEntity one = this.getById(id);
        if (one.getStatus().equals(QuestionnaireConstant.release)) {
            return false;
        } else {
            questionnaire.setUpdateTime(new Date());
            this.updateById(questionnaire);
            return true;
        }

    }

    @Override
    public String getShortUrlForLink(Integer id) {
        String url = "http://127.0.0.1:8085/#/questionnaire/questionnaire/?i=" + id + "&" + "q=1";
        return url;
    }


    @Override
    public void saveQuestionnaire(QuestionnaireEntity questionnaire) {
        //        保存一共创建问卷数量的计费
        int number = questionnaire.getLimitNumber();
        UserEntity byId = userService.getById(questionnaire.getUserId());
        userService.expenseUtoT(questionnaire.getUserId(),
                ExpenseConstants.createQuestionnaire.getStatenum()
                        .multiply(new BigDecimal(number)));

        Integer left = byId.getCreateNumber() - number;
        byId.setCreateNumber(left);
        userService.updateById(byId);
//        保存问卷
        questionnaire.setStartTime(new Date());
        this.save(questionnaire);
    }

    @Override
    public List<QuestionnaireEntity> findByKeyWord(String keyword) {

        return questionnaireDao.findByKeyWord(keyword);
    }


    AnswererTeamDao answererTeamDao;

    /**
     * wanganwei: 向用户分组发送问卷
     */
    //TODO waw:(teamId:群组id，id：问卷id)
    public void releaseToTeam(Integer teamId, Integer id) {
//        int[] userid;
//        for (Integer userId: userid){
//            userId = AnswererDao
//        }
//        int[] userid;
        QuestionnaireEntity entity = this.getById(id);
        entity.setReleaseTime(new Date());
        entity.setStatus(QuestionnaireConstant.release.getStatus());
        this.updateById(entity);

        List<Integer> userlist;
        userlist = answererTeamDao.findAnswererByTeamId(teamId);
        int[] answerers = new int[userlist.size()];
        for (int i = 0; i < userlist.size(); i++) {
            answerers[i] = userlist.get(i);
        }

//        创建答卷数量
        List<ResultEntity> collect = Arrays.stream(answerers).mapToObj(item -> {
                    ResultEntity resultEntity = new ResultEntity();
                    resultEntity.setAnswererId(item);
                    resultEntity.setAnswerList(entity.getProblemList());
                    resultEntity.setIsFinish(0);
                    resultEntity.setQuestionnaireName(entity.getQuestionnaireName());
                    resultEntity.setQuestionnaireId(id);
                    resultEntity.setLimitTime(entity.getLimitTime());
                    return resultEntity;
                }
        ).collect(Collectors.toList());
        resultService.saveBatch(collect);
           /*
            QuestionnaireEntity entity = this.getById(id);
            entity.setReleaseTime(new Date());
            entity.setStatus(QuestionnaireConstant.release.getStatus());
            this.updateById(entity);
            UserEntity byId = userService.getById(entity.getUserId());
            Integer left = byId.getCreateNumber() - entity.getLimitNumber();
            byId.setCreateNumber(left);

            List<ResultEntity> collect = Arrays.stream(answerers).map(item -> {
                        ResultEntity resultEntity = new ResultEntity();
                        resultEntity.setAnswererId(item);
                        resultEntity.setAnswerList(entity.getProblemList());
                        resultEntity.setIsFinish(0);
                        resultEntity.setQuestionnaireName(entity.getQuestionnaireName());
                        resultEntity.setQuestionnaireId(id);
                        return resultEntity;
                    }
            ).collect(Collectors.toList());
            resultService.saveBatch(collect);*/
    }

    @Override
    public List<Integer> findByTeamIds(Integer[] teamIds) {
        List<Integer> result = questionnaireDao.findByTeamIds(teamIds);
        return result;
    }
}